Coupled computer systems with separate memory systems arise in various settings, ranging from loosely coupled multiprocessor systems to large-scale distributed systems, such as the Internet. The coupling of these systems can be regarded as maintaining shared data between the processors. For instance, if one processor provides a file service, another processor may be running an application that requires access to data contained in these files, and thus needs the data shared with it. When a file is changed, the application must be able to reread the file and thereby read the new data. Similarly, in a distributed computer game, a change in geometry of some object in the virtual world needs to be communicated to each player that has visibility to that object.
Conventionally, data sharing is achieved by either pushing or pulling the data. In the former case, the holder of the data recognizes the receiver needs to have a copy of this data, and then serializes and transmits the data it believes is of interest to the receiver. In the latter case, the node interested in the data requests the data by some form of identification, such as file and offset, and the holder of the data responds as above. Typically, data objects are transmitted in their entirety. However, this can lead to unbounded bandwidth requirements relative to the amount of data being modified. For example, the modification of a single byte in a file can result in the entire contents of the file being retransmitted. Similarly, the change of a single parameter in a geometric description of an object in a virtual world can result in the entire description being retransmitted. The use of conventional data compression techniques on such serialized data does not completely address the underlying inefficiency of retransmitting an entire large data object which has only had a small modification.
Data objects are commonly “structured” in the sense of being a non-linear structure that contains pointers to subportions, which may be shared between data objects or may be referenced multiple times within one data object. Conventionally, a structured data object is serialized as part of transmission, sometimes simply including the actual data of a subobject in place of each reference. In other cases, each pointer is translated to some high-level network pointer representation and that representation is transmitted over the network. Typically, this requires transmitting a definition or designation of the object over the network and associating it with an object ID, and then transmitting the object ID as a network representation of the pointer to this object. To reduce bandwidth, the resulting serialized data can be compressed. However, this conventional approach of doing serialization and compression separately can incur substantial overhead on transmission as well as on reception of structured data, as a result of translating the data to and from the network representation.
Accordingly, it would be an advance in the art to provide more efficient processor to processor transmission of structured data.